home *** CD-ROM | disk | FTP | other *** search
/ STraTOS 1997 April & May / STraTOS 1 - 1997 April & May.iso / CD01 / PRGMANIA / QEDSRC / PROJEKT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-14  |  50.6 KB  |  2,281 lines
  1. #include "global.h"
  2. #include "av.h"
  3. #include "ausgabe.h"
  4. #include "clipbrd.h"
  5. #include "comm.h"
  6. #include "dd.h"
  7. #include "desktop.h"
  8. #include "disk.h"
  9. #include "edit.h"
  10. #include "event.h"
  11. #include "kurzel.h"
  12. #include "file.h"
  13. #include "find.h"
  14. #include "icon.h"
  15. #include "menu.h"
  16. #include "mintlib.h"
  17. #include "obj.h"
  18. #include "printer.h"
  19. #include "rsc.h"
  20. #include "scroll.h"
  21. #include "set.h"
  22. #include "text.h"
  23. #include "trash.h"
  24. #include "windows.h"
  25. #include "projekt.h"
  26.  
  27. #include "debug.h"
  28.  
  29. /* exprortierte Variablen **************************************************/
  30. WORD        prj_type;
  31. PATH        def_prj_path;
  32.  
  33. /****** DEFINES ************************************************************/
  34.  
  35. #define KIND    (NAME|CLOSER|MOVER|INFO|SIZER|UPARROW|DNARROW|VSLIDE|SMALLER)
  36. #define FLAGS    (WI_FONTSIZE|WI_REDRAW)
  37.  
  38. #define TEMP_PRJ    "TEMP$.QPJ"
  39. #define TEMP_LINK 10001
  40.  
  41. /****** TYPES **************************************************************/
  42.  
  43. typedef struct {            /* für Dreaddir */
  44.         LONG        inode;
  45.         FILENAME name;
  46. } DIRENTRY;
  47.  
  48. /****** VAR ****************************************************************/
  49. LOCAL SET        used_info;                        /* Icon-Nr für Text und Fenster */
  50. LOCAL WORD        do_find_icon, namenlos_anz;
  51. LOCAL PATH        df_path;
  52. LOCAL WORD        def_icon;                        /* Icon für Defaultprojekt */
  53. LOCAL RING        lastPos;
  54.  
  55. /****** FUNCTIONS **********************************************************/
  56.  
  57. LOCAL VOID        icon_exist            (WORD icon, SET actions);
  58. LOCAL BOOLEAN    icon_test            (WORD icon, WORD action);
  59. LOCAL WORD        icon_edit            (WORD icon, WORD action);
  60. LOCAL BOOLEAN    icon_drag            (WORD icon, WORD source);
  61. LOCAL VOID        draw_line            (WINDP window, WORD line);
  62. LOCAL VOID        wi_draw                (WINDP window, CONST RECT *d);
  63. LOCAL VOID        wi_click             (WINDP window, MKINFO *mk);
  64. LOCAL VOID        wi_unclick            (WINDP window);
  65. LOCAL BOOLEAN    wi_key                (WINDP window, MKINFO *mk);
  66. LOCAL VOID        wi_snap                (WINDP window, RECT *new, WORD mode);
  67. LOCAL VOID        wi_iconify            (WINDOWP window);
  68. LOCAL VOID        wi_uniconify        (WINDOWP window);
  69.  
  70. LOCAL LONG        get_direntry        (LONG handle, UBYTE *pfad, DIRENTRY *buf, XATTR *attr);
  71.  
  72. LOCAL BOOLEAN    dfind                 (UBYTE *pfad, UBYTE *df_muster, WORD icon);
  73. LOCAL BOOLEAN    dfind_rek            (UBYTE *pfad, UBYTE *df_muster, WORD icon);
  74.  
  75. LOCAL VOID        get_prj_line        (WORD link, WORD line, UBYTE *str);
  76. LOCAL VOID        get_prj_line_file (WORD link, WORD line, UBYTE *str);
  77. LOCAL WORD        del_from_projekt    (WORD link, WORD line);
  78. LOCAL BOOLEAN    open_prj             (WORD icon);
  79. LOCAL VOID        destruct             (WORD icon);
  80. LOCAL VOID        crt_prj                (WORD icon, WINDP window);
  81. LOCAL BOOLEAN    info_projekt        (WORD icon);
  82.  
  83. LOCAL VOID        select_def_prj     (VOID);
  84. LOCAL BOOLEAN    get_lastPos         (CONST UBYTE *name, WORD *x, LONG *y);
  85. LOCAL VOID        insert_lastPos     (CONST UBYTE *name, WORD x, LONG y);
  86.  
  87. /*****************************************************************************/
  88.  
  89. LOCAL LONG        p_maxvalue;
  90. LOCAL    DIALINFO    scan_box;
  91.  
  92. VOID start_prjscan(CONST UBYTE *name, LONG max_value)
  93. {
  94.     p_maxvalue = max(max_value,1);
  95.     fill_ptext(prjscan, PNAME, name);
  96.     fill_ptext(prjscan, PDATEI, "");
  97.     prjscan[PBOX2].ob_width = 1;
  98.     open_dial(prjscan, TRUE, NULL, &scan_box);
  99.     dial_draw(&scan_box);
  100. }
  101.  
  102. VOID do_prjscan (CONST UBYTE *name, LONG value)
  103. {
  104.     LONG max_len, help;
  105.  
  106.     fill_ptext(prjscan,PDATEI,name);
  107.     max_len = prjscan[PBOX1].ob_width;
  108.     help = max((max_len*value)/p_maxvalue,1);
  109.     prjscan[PBOX2].ob_width = (short) min(max_len, help);
  110.     draw_Objc(prjscan, PDATEI, 1);
  111.     draw_Objc(prjscan, PBOX2, 1);
  112. }
  113.  
  114. VOID end_prjscan (VOID)
  115. {
  116.     dial_end(&scan_box);
  117. }
  118.  
  119. /*****************************************************************************/
  120.  
  121. WORD anz_prj_loaded(VOID)
  122. {
  123.     return setcard(used_info);
  124. }
  125.  
  126. WORD prj_still_loaded(CONST UBYTE *name)
  127. {
  128.     WORD i, min;
  129.  
  130.     min = setmin(used_info);
  131.     for (i=setmax(used_info); i>=min; i--)
  132.         if (setin(used_info,i))
  133.         {
  134.             TEXTP t_ptr = get_text(i);
  135.             
  136. /*            if (!t_ptr->namenlos && filematch(t_ptr->filename, name))*/
  137.             if (!t_ptr->namenlos && strcmp(t_ptr->filename, name)==0)
  138.                 return i;
  139.         }
  140.     return -1;
  141. }
  142.  
  143. LOCAL VOID do_for_prj(WORD icon, SET s, WORD (*do_it)(WORD,WORD), BOOLEAN verbose)
  144. {
  145.     TEXTP     t_ptr, t_ptr2;
  146.     LINEP     lauf;
  147.     WORD        min, i, anz, soll, erg;
  148.     PATH        name;
  149.     FILENAME file;
  150.  
  151.     t_ptr = get_text(icon);
  152.     if (verbose)
  153.     {
  154.         t_ptr2 = get_text(icon);
  155.         if (t_ptr2->namenlos)
  156.             strcpy(file, t_ptr2->filename);
  157.         else
  158.             file_name(t_ptr2->filename,file, FALSE);
  159.         start_prjscan(file,setcard(s));
  160.     }
  161.  
  162.     min = setmin(s);
  163.     /* So wg. DO_CLEAR */
  164.     for (i=setmax(s); i>=min; i--)
  165.     {
  166.         if (setin(s,i))
  167.         {
  168.             lauf = get_line(&t_ptr->text,i);
  169.             lauf->info |= 128;
  170.         }
  171.     }
  172.     soll = setcard(s);
  173.     anz = i = 0;
  174.     while (TRUE)
  175.     {
  176.         if (abbruch())
  177.         {
  178.             if (anz<soll && note(2,BREAK)==1) break;
  179.         }
  180.         lauf = get_line(&t_ptr->text,i);
  181.         if (lauf==NULL) break;
  182.         if (lauf->info&128)
  183.         {
  184.             anz++;
  185.             lauf->info &= (~128);                /* sonst Endlosschleife */
  186.             if (verbose)
  187.             {
  188.                 get_prj_line_file(icon,i,name);
  189.                 if (name[0]==EOS) break;
  190.                 file_name(name,file, FALSE);
  191.                 do_prjscan(file,anz);
  192.             }
  193.             erg = (*do_it)(icon,i);
  194.             if (erg<0) break;
  195.             if (erg==0)
  196.             {
  197.                 if (anz<soll && note(2,BREAK)==1) break;
  198.             }
  199.         }
  200.         else
  201.             i++;
  202.     }
  203.     lauf = FIRST(&t_ptr->text);
  204.     while (!IS_TAIL(lauf))
  205.     {
  206.         lauf->info &= (~128);
  207.         NEXT(lauf);
  208.     }
  209.     if (verbose) end_prjscan();
  210. }
  211.  
  212. LOCAL VOID do_for_prj2(WORD icon, SET s, BOOLEAN (*do_it)(WORD))
  213. {
  214.     WORD    i, t_icon, anz, soll;
  215.     TEXTP t_ptr, t_ptr2;
  216.     PATH    name;
  217.     FILENAME file;
  218.  
  219.     t_ptr = new_text(TEMP_LINK);
  220.     if (t_ptr==NULL) return;
  221.  
  222.     t_ptr2 = get_text(icon);
  223.     if (t_ptr2->namenlos)
  224.         strcpy(file, t_ptr2->filename);
  225.     else
  226.         file_name(t_ptr2->filename,file, FALSE);
  227.     start_prjscan(file,setcard(s));
  228.  
  229.     soll = setcard(s);
  230.     for (i=setmin(s),anz=0; anz<soll; i++)
  231.     {
  232.         if (setin(s,i))
  233.         {
  234.             anz++;
  235.             get_prj_line_file(icon,i,name);
  236.             if (name[0]==EOS) break;
  237.             file_name(name,file, FALSE);
  238.             do_prjscan(file,anz);
  239.             if ((t_icon=still_loaded(name))>=0)
  240.             {
  241.                 if (!(*do_it)(t_icon)) break;
  242.             }
  243.             else
  244.             {
  245.                 set_text_name(t_ptr, name, FALSE);
  246.                 if (load(t_ptr, FALSE)<0)
  247.                     if (anz<soll && note(2,BREAK)==1) break;
  248.                 if (!(*do_it)(TEMP_LINK)) break;
  249.                 clear_text(t_ptr);
  250.             }
  251.         }
  252.         if (abbruch())
  253.         {
  254.             if (anz<soll && note(2,BREAK)==1) break;
  255.         }
  256.     }
  257.     destruct_text(t_ptr);
  258.     end_prjscan();
  259. }
  260.  
  261. LOCAL BOOLEAN delete_prj(WORD icon)
  262. {
  263.     TEXTP t_ptr = get_text(icon);
  264.     WORD    antw;
  265.     FILENAME name;
  266.  
  267. /* if (!ist_leer(&t_ptr->text) && t_ptr->moved!=0)
  268.  
  269.     Ungeschickt: wenn man mit ^X alles gelöscht hat, wird nicht nachgefragt
  270.     bzw. gesichert, sondern die Datei so gelassen, wie sie war! */
  271.  
  272.     if (t_ptr->moved!=0)
  273.     {
  274.         if (quick_close)
  275.             antw = 1;
  276.         else
  277.         {
  278.             if (t_ptr->namenlos)
  279.                 strcpy(name, t_ptr->filename);
  280.             else
  281.                 file_name(t_ptr->filename, name, FALSE);
  282.             antw = snote(1, MOVED, name);
  283.         }
  284.         if (antw==1)
  285.         {
  286.             if (do_icon(icon,DO_SAVE)<0)
  287.                 return (FALSE);
  288.         }
  289.         if (antw==3) return(FALSE);
  290.     }
  291.     return (TRUE);
  292. }
  293.  
  294. LOCAL VOID chg_prj_name(WORD icon)
  295. {
  296.     WINDP         window;
  297.     FILENAME     name;
  298.     TEXTP         t_ptr = get_text(icon);
  299.  
  300.     file_name(t_ptr->filename, name, TRUE);
  301.     window = get_window (icon);
  302.     set_icon_name(icon,name);
  303.     set_wname(window,name);
  304. }
  305.  
  306. /***************************************************************************/
  307. /* Operation vorhanden ?                                                                    */
  308. /***************************************************************************/
  309.  
  310. LOCAL VOID icon_exist(WORD icon, SET actions)
  311. {
  312.     setclr(actions);
  313.     if (icon & SUB_ICON)
  314.     {
  315.         setincl(actions,DO_CLEAR);
  316.         setincl(actions,DO_OPEN);
  317.         setincl(actions,DO_INFO);
  318.         setincl(actions,DO_FIND);
  319.         setincl(actions,DO_HELP);
  320.     }
  321.     else
  322.     {
  323.         WINDP window = get_window(icon);
  324.         TEXTP t_ptr = get_text(icon);
  325.  
  326.         if (window->flags & WI_ICONIFIED)
  327.         {
  328.             setincl(actions,DO_DESTRUCT);
  329.         }
  330.         else
  331.         {
  332.             if (window->opened)
  333.                 setincl(actions, DO_CLOSE);
  334.             setincl(actions, DO_CLEAR);
  335.             setincl(actions, DO_SELALL);
  336.             setincl(actions, DO_DESTRUCT);
  337.             setincl(actions, DO_OPEN);
  338.             setincl(actions, DO_INFO);
  339.             setincl(actions, DO_FIND);
  340.             if (!t_ptr->namenlos)
  341.                 setincl(actions, DO_ABAND);
  342.             setincl(actions, DO_SAVE);
  343.             setincl(actions, DO_SAVENEW);
  344.             setincl(actions, DO_GOTO);
  345.             setincl(actions, DO_UPDATE);
  346.             setincl(actions, DO_PRINT);
  347.             setincl(actions, DO_HELP);
  348.             setincl(actions, DO_ADD);
  349.             setincl(actions, DO_AUTOSAVE);
  350.         }
  351.     }
  352. }
  353.  
  354. /***************************************************************************/
  355. /* Operation testen                                                                            */
  356. /***************************************************************************/
  357.  
  358. LOCAL BOOLEAN icon_test(WORD icon, WORD action)
  359. {
  360.     BOOLEAN    erg;
  361.  
  362.     if (icon & SUB_ICON)
  363.     {
  364.         switch(action)
  365.         {
  366.             case DO_CLEAR    :    erg = TRUE; break;
  367.             case DO_OPEN    :    erg = TRUE; break;
  368.             case DO_INFO    :    erg = TRUE; break;
  369.             case DO_FIND    :    erg = find_dial(TRUE); break;
  370.             case DO_HELP    :    erg = TRUE; break;
  371.             default            :    erg = FALSE;
  372.         }
  373.     }
  374.     else
  375.     {
  376.         FILENAME name;
  377.         TEXTP t_ptr = get_text(icon);
  378.         WINDP window = get_window(icon);
  379.  
  380.         switch(action)
  381.         {
  382.             case DO_CLEAR    :    erg = delete_prj(icon); break;
  383.             case DO_SELALL :    erg = TRUE; break;
  384.             case DO_CLOSE    :    erg = window->opened;    break;
  385.             case DO_DESTRUCT: erg = delete_prj(icon); break;
  386.             case DO_OPEN    :    erg = TRUE; break;
  387.             case DO_INFO    :    erg = TRUE; break;
  388.             case DO_FIND    :    erg = find_dial(TRUE); break;
  389.             case DO_ABAND    :    if (t_ptr->namenlos)
  390.                                         erg = FALSE;
  391.                                     else
  392.                                     {
  393.                                         erg = TRUE;
  394.                                         if (!ist_leer(&t_ptr->text) && t_ptr->moved!=0)
  395.                                         {
  396.                                             file_name(t_ptr->filename, name, FALSE);
  397.                                             erg = (snote(1,ABANDON,name)==1);
  398.                                         }
  399.                                     }
  400.                                     break;
  401.             case DO_SAVE    :
  402.                 erg = TRUE; break;
  403.             case DO_SAVENEW:
  404.                 erg = TRUE; break;
  405.             case DO_GOTO    :
  406.                 erg = goto_line_dial(); break;
  407.             case DO_UPDATE :
  408.                 erg = TRUE; break;
  409.             case DO_PRINT    :
  410.                 erg = TRUE; break;
  411.             case DO_HELP    :
  412.                 erg = TRUE; break;
  413.             case DO_ADD     :
  414.                 erg = diskfind_dial(df_path, df_name);
  415.                 break;
  416.             case DO_AUTOSAVE :
  417.                 if (as_proj && t_ptr->moved)
  418.                 {
  419.                     WORD            min, btn;
  420.  
  421.                     min = local_time->tm_min - t_ptr->count;
  422.                     if (min >= as_proj_min)
  423.                     {
  424.                         if (as_proj_ask)                /* Nachfrage ? */
  425.                         {
  426.                             FILENAME     name;
  427.  
  428.                             if (t_ptr->namenlos)
  429.                                 strcpy(name, t_ptr->filename);
  430.                             else
  431.                                 file_name(t_ptr->filename, name, FALSE);
  432.                             mybeep();
  433.                             btn = snote(2, ASAVEASK, name);
  434.                             if (btn == 1)
  435.                                 as_proj = FALSE;
  436.                         }
  437.                         else
  438.                             btn = 2;
  439.  
  440.                         t_ptr->count = local_time->tm_min;
  441.                         erg = (btn == 2);
  442.                     }
  443.                     else
  444.                         erg = FALSE;
  445.                 }
  446.                 else
  447.                 {
  448.                     t_ptr->count = local_time->tm_min;
  449.                     erg = FALSE;
  450.                 }
  451.                 break;
  452.             default            :
  453.                 erg = FALSE;
  454.         }
  455.     }
  456.     return erg;
  457. }
  458.  
  459. /***************************************************************************/
  460. /* Operation durchführen                                                                    */
  461. /***************************************************************************/
  462.  
  463. LOCAL WORD do_open(WORD prj_icon, WORD i)
  464. {
  465.     PATH    name;
  466.     WORD    icon;
  467.     BOOLEAN    prj;
  468.  
  469.     get_prj_line_file(prj_icon, i, name);
  470.     prj = filematch(name, "*.QPJ");
  471.     if (prj)
  472.     {
  473.         if ((icon = prj_still_loaded(name))>=0)
  474.         {
  475.             if (do_icon(icon, DO_OPEN)<0)                 /* Nur Fenster öffnen */
  476.             {
  477.                 note(1, NOWINDOW);
  478.                 return -1;                                        /* keine weiteren Versuche */
  479.             }
  480.             return 1;                                            /* OK */
  481.         }
  482.         else
  483.             if (global_shift)
  484.                 return load_edit(name, TRUE, -1, -1, NULL);/* Laden als Text und öffnen */
  485.             else
  486.                 return load_projekt(name, TRUE, -1, -1, NULL);/* Laden als Projekt und öffnen */
  487.     }
  488.     else
  489.     {
  490.         if ((icon = still_loaded(name))>=0)
  491.         {
  492.             if (do_icon(icon, DO_OPEN)<0)                 /* Nur Fenster öffnen */
  493.             {
  494.                 note(1, NOWINDOW);
  495.                 return -1;                                        /* keine weiteren Versuche */
  496.             }
  497.             return 1;                                            /* OK */
  498.         }
  499.         else
  500.         {
  501.             WORD x;
  502.             LONG y;
  503.  
  504.             icon = load_edit(name, TRUE, -1, -1, NULL);    /* Laden als Text und öffnen */
  505.             if (get_lastPos(name, &x, &y))
  506.             {
  507.                 desire_x = x;
  508.                 desire_y = y;
  509.                 Icon_edit(icon, DO_GOTO);
  510.             }
  511.             else
  512.                 insert_lastPos(name, 0, 0);
  513.             return icon;
  514.         }
  515.     }
  516. }
  517.  
  518. LOCAL BOOLEAN do_find(WORD icon)
  519. {
  520.     WORD    erg;
  521.     TEXTP t_ptr = get_text(icon);
  522.  
  523.     erg = start_find(t_ptr,TRUE);
  524.     if (erg==1)
  525.         add_to_projekt(do_find_icon, t_ptr->filename, FALSE);
  526.     return (erg!=-1);
  527. }
  528.  
  529. LOCAL WORD icon_edit(WORD icon, WORD action)
  530. {
  531.     PATH    name;
  532.     WORD    erg;
  533.  
  534.     erg = 0;
  535.     if (icon&SUB_ICON)
  536.     {
  537.         WINDP window;
  538.         TEXTP t_ptr;
  539.         SET    help;
  540.  
  541.         icon &= (~SUB_ICON);
  542.         window = get_window(icon);
  543.         if (sel_window==window)
  544.             setcpy(help,sel_objs);
  545.         else
  546.             setclr(help);
  547.         switch (action)
  548.         {
  549.             case DO_CLEAR    :
  550.                 do_for_prj(icon,help,del_from_projekt,FALSE);
  551.                 break;
  552.             case DO_OPEN    :
  553.                 do_for_prj(icon,help,do_open,FALSE);
  554.                 break;
  555.             case DO_INFO    :
  556.                 do_for_prj2(icon,help,info_edit);
  557.                 break;
  558.             case DO_FIND    :
  559.                 do_find_icon = crt_new_prj("",-1,-1,NULL);
  560.                 if (do_find_icon<0)
  561.                     break;
  562.                 if (do_icon(do_find_icon,DO_OPEN)<0)
  563.                 {
  564.                     note(1, NOWINDOW);
  565.                     if (no_desktop)
  566.                     {
  567.                         Icon_edit(icon, DO_DESTRUCT);
  568.                         break;
  569.                     }
  570.                 }
  571.                 do_for_prj2(icon,help,do_find);
  572.                 t_ptr = get_text(do_find_icon);
  573.                 if (t_ptr->moved)                                    /* etwas gefunden? */
  574.                 {
  575.                     t_ptr->moved = 0;
  576.                     window = get_window(do_find_icon);
  577.                     change_window(window, FALSE);
  578.                     set_sliders(window, VERTICAL, SLPOS+SLSIZE);
  579.                     redraw_window(window,&window->work);
  580.                 }
  581.                 else
  582.                     Icon_edit(do_find_icon, DO_DESTRUCT);    /* wenn nicht, gleich wieder zu */
  583.                 break;
  584.             case DO_HELP    :
  585.                 erg = call_hyp(STRING(HYPPRJSTR));
  586.                 break;
  587.         }
  588.         erg = 1;
  589.     }
  590.     else
  591.     {
  592.         TEXTP     t_ptr = get_text(icon);
  593.         WINDP     window = get_window(icon);
  594.         WORD        i;
  595.         SET        help;
  596.         FILENAME file;
  597.         PATH        h;
  598.         FSEL        fsel;
  599.  
  600.         switch(action)
  601.         {
  602.             case DO_DESTRUCT:
  603.             case DO_CLEAR    :
  604.                 if (icon == def_icon)
  605.                 {
  606.                     def_icon = -1;
  607.                     set_def_prj();
  608.                 }
  609.                 destruct(icon);
  610.                 erg = 1;
  611.                 break;
  612.             case DO_SELALL :
  613.                 if (window != sel_window)
  614.                     unclick_window();
  615.                 if (!ist_leer(&t_ptr->text))
  616.                 {
  617.                     sel_window = window;
  618.                     for (i = (short) t_ptr->text.lines; (--i)>=0; )
  619.                         setincl(sel_objs,i);
  620.                     redraw_window(window,&window->work);
  621.                 }
  622.                 erg = 1;
  623.                 break;
  624.             case DO_CLOSE    :
  625.                 close_window(window);
  626.                 if (icon == def_icon)
  627.                 {
  628.                     def_icon = -1;
  629.                     set_def_prj();
  630.                 }
  631.                 erg = 1;
  632.                 break;
  633.             case DO_OPEN    :
  634.                 if (!open_prj (icon))
  635.                     erg = -1;
  636.                 else
  637.                     erg = 1;
  638.                 break;
  639.             case DO_INFO    :
  640.                 info_projekt(icon);
  641.                 erg = 1;
  642.                 break;
  643.             case DO_FIND    :
  644.                 setclr(help);
  645.                 for (i = (short) t_ptr->text.lines; (--i)>=0; )
  646.                     setincl(help,i);
  647.                 do_find_icon = crt_new_prj("",-1,-1,NULL);
  648.                 if (do_find_icon<0)
  649.                     break;
  650.                 if (do_icon(do_find_icon,DO_OPEN)<0)
  651.                 {
  652.                     note(1, NOWINDOW);
  653.                     if (no_desktop)
  654.                     {
  655.                         Icon_edit(icon, DO_DESTRUCT);
  656.                         break;
  657.                     }
  658.                 }
  659.                 do_for_prj2(icon,help,do_find);
  660.                 t_ptr = get_text(do_find_icon);
  661.                 if (t_ptr->moved)                                    /* etwas gefunden? */
  662.                 {
  663.                     t_ptr->moved = 0;
  664.                     window = get_window(do_find_icon);
  665.                     change_window(window, FALSE);
  666.                     set_sliders(window, VERTICAL, SLPOS+SLSIZE);
  667.                     redraw_window(window,&window->work);
  668.                 }
  669.                 else
  670.                     Icon_edit(do_find_icon, DO_DESTRUCT);    /* wenn nicht, gleich wieder zu */
  671.                 erg = 1;
  672.                 break;
  673.             case DO_ABAND    :
  674.                 strcpy(name, t_ptr->filename);
  675.                 desire_y = window->doc.y+1;
  676.                 window->init = 1; /* das will ich wieder haben */
  677.                 destruct_window(window);
  678.                 destruct_text(t_ptr);
  679.                 del_icon_from_desk(icon);
  680.                 del_icon(icon);
  681.                 setexcl(used_info,icon);
  682.                 icon = load_projekt(name,TRUE,-1,-1,NULL);
  683.                 if (icon > 0)
  684.                 {
  685.                     t_ptr = get_text(icon);
  686.                     if (t_ptr!=NULL)
  687.                     {
  688.                         i = (short) (desire_y - window->doc.y);
  689.                         arrow_window(window,WA_DNLINE,i);
  690.                         restore_edit();
  691.                         open_prj(icon);
  692.  
  693.                         memset(msgbuff, 0, (WORD) sizeof(msgbuff));
  694.                         msgbuff[0] = WM_TOPPED;
  695.                         msgbuff[3] = window->handle;
  696.                         send_msg(gl_apid);
  697.         
  698.                         erg = 1;
  699.                     }
  700.                 }
  701.                 break;
  702.             case DO_SAVE    :
  703.                 if (!t_ptr->namenlos)
  704.                 {
  705.                     if (save(t_ptr) < 0)
  706.                         erg = -1;
  707.                     else
  708.                     {
  709.                         change_window(window, FALSE);
  710.                         erg = 1;
  711.                     }
  712.                     break;
  713.                 }
  714.                 /* Bei Namenlos zu DO_SAVENEW */
  715.             case DO_SAVENEW:
  716.                 strcpy(fsel.name,"");
  717.                 strcpy(fsel.suffix,"*.QPJ");
  718.                 if (save_new(name,&fsel,STRING(SAVEPRJSTR)))
  719.                 {
  720.                     make_ext(name,"qpj");
  721.                     if ((erg=save_as(t_ptr,name))==0)
  722.                     {
  723.                         if (t_ptr->namenlos || note(1,GETNAME)==1)
  724.                         {
  725.                             set_text_name(t_ptr, name, FALSE);
  726.                             chg_prj_name(icon);
  727.                             t_ptr->moved = 0;
  728.                             t_ptr->file_date_time = file_time(name,NULL,NULL);
  729.                             t_ptr->readonly = file_readonly(name);
  730.                         }
  731.                         change_window(window, FALSE);
  732.                         erg = 1;
  733.                     }
  734.                 }
  735.                 break;
  736.             case DO_GOTO    :
  737.                 i = (short) (desire_y - window->doc.y);
  738.                 arrow_window(window,WA_DNLINE,i);
  739.                 erg = 1;
  740.                 break;
  741.             case DO_UPDATE :
  742.                 redraw_window(window, &window->work);
  743.                 erg = 1;
  744.                 break;
  745.             case DO_PRINT    :
  746.                 if (t_ptr->namenlos)
  747.                     strcpy(file, t_ptr->filename);
  748.                 else
  749.                     file_name(t_ptr->filename, file, FALSE);
  750.                 if (prn_options(file, FALSE))
  751.                     txt_drucken(file,t_ptr);
  752.                 erg = 1;
  753.                 break;
  754.             case DO_HELP    :
  755.                 erg = call_hyp(STRING(HYPPRJSTR));
  756.                 break;
  757.             case DO_ADD :
  758.                 if (df_path[0]!=EOS)             /* Pfad durchsuchen */
  759.                 {
  760.                     Busy_mouse();
  761.                     strcpy(h, df_path);
  762.                     if (!caseSens(df_path, NULL))
  763.                         str_upper(df_name);
  764.                     if (df_rekursiv)
  765.                         dfind_rek(h, df_name, icon);
  766.                     else
  767.                         dfind(h, df_name, icon);
  768.                     Last_mouse();
  769.                     redraw_window(window, &window->work);
  770.                 }
  771.                 break;
  772.             case DO_AUTOSAVE:
  773.                 icon_edit(icon, DO_SAVE);
  774.                 break;
  775.         }
  776.     }
  777.     return erg;
  778. }
  779.  
  780. /***************************************************************************/
  781. /* Ein Icon wurde auf ein Projekt-Icon geschoben                                    */
  782. /***************************************************************************/
  783.  
  784. LOCAL BOOLEAN icon_drag (WORD icon, WORD source)
  785. {
  786.     TEXTP     t_ptr;
  787.     WINDP     window;
  788.     BOOLEAN    erg = FALSE;
  789.     PATH        h;
  790.  
  791.     switch (source)
  792.     {
  793.         case DRAGDROP_FILE :
  794.             if (drag_filename[0] != EOS)
  795.             {
  796.                 erg = add_to_projekt(icon, drag_filename, TRUE);
  797.                 drag_filename[0] = EOS;
  798.             }
  799.             break;
  800.         case DRAGDROP_PATH :
  801.             if (drag_filename[0] != EOS)
  802.             {
  803.                 window = get_window(icon);
  804.                 strcpy(df_path, drag_filename);
  805.                 erg = diskfind_dial(df_path, df_name);
  806.                 if (erg)
  807.                 {
  808.                     Busy_mouse();
  809.                     strcpy(h, df_path);
  810.                     if (!caseSens(df_path, NULL))
  811.                         str_upper(df_name);
  812.                     if (df_rekursiv)
  813.                         dfind_rek(h, df_name, icon);
  814.                     else
  815.                         dfind(h, df_name, icon);
  816.                     Last_mouse();
  817.                     redraw_window(window, &window->work);
  818.                 }
  819.                 drag_filename[0] = EOS;
  820.             }
  821.             break;
  822.         case DRAGDROP_DATA :
  823.             mybeep();
  824.             erg = FALSE;
  825.             break;
  826.         default:
  827.             t_ptr = get_text(source);
  828.             window = get_window(source);
  829.             if (t_ptr!=NULL && !t_ptr->namenlos && window!=NULL &&
  830.                 (window->class==CLASS_EDIT || window->class==CLASS_PROJEKT))
  831.             {
  832.                 erg = add_to_projekt(icon, t_ptr->filename, TRUE);
  833.             }
  834.     }
  835.     return erg;
  836. }
  837. /***************************************************************************/
  838.  
  839.  
  840. /*
  841.  * Dateien für Projekt suchen.
  842.  *
  843.  * Unter MiNT wird mit Dopendir/Dreaddir gesucht, da Fsfirst/Fsnext
  844.  * auf MinixFS nichts finden!
  845.  *
  846.  */
  847. LONG    get_direntry(LONG handle, UBYTE *pfad, DIRENTRY *buf, XATTR *attr)
  848. {
  849.     LONG    r;
  850.     PATH    tmp;
  851.  
  852.     r = Dreaddir((WORD) sizeof(DIRENTRY), handle, (UBYTE *)buf);    /* Eintrag holen */
  853.     if (r < 0)
  854.         return r;
  855.     strcpy(tmp, pfad);
  856.     strcat(tmp, buf->name);
  857.     r = Fxattr(0, tmp, attr);        /* Attribute holen */
  858.     if (r < 0)
  859.         return r;
  860.     return 0;
  861. }
  862.  
  863. LOCAL BOOLEAN dfind(UBYTE *pfad, UBYTE *df_muster, WORD icon)
  864. /* Sammelt alle Dateien in einem Pfad auf */
  865. {
  866.     TEXTP     t_ptr;
  867.     UBYTE     *ptr;
  868.     BOOLEAN    raus;
  869.     WORD        t_icon;
  870.     PATH        suchPfad;
  871.     LONG        dh;
  872.  
  873.     if (s_str[0]!=EOS)
  874.     {
  875.         t_ptr = new_text(TEMP_LINK);
  876.         if (t_ptr==NULL) return TRUE;
  877.     }
  878.     strcpy(suchPfad, pfad);
  879.     ptr = pfad + strlen(pfad);
  880.     dh = Dopendir(suchPfad, 0);
  881.     if (dh != -32)
  882.     {
  883.         DIRENTRY entry;
  884.         XATTR     attr;
  885.         LONG        fehler;
  886.  
  887.         do_find_icon = icon;
  888.         if (dh < 0)
  889.             return FALSE;
  890.         raus = FALSE;
  891.         fehler = get_direntry(dh, suchPfad, &entry, &attr);
  892.         while (fehler == 0 && !raus)
  893.         {
  894.             if ((attr.attr != 16) && filematch(entry.name, df_muster))
  895.             {
  896.                 strcpy(ptr, entry.name);
  897.                 if (s_str[0] !=EOS)
  898.                 {
  899.                     if ((t_icon=still_loaded(pfad)) <0)
  900.                     {
  901.                         set_text_name(t_ptr, pfad, FALSE);
  902.                         if (load(t_ptr,FALSE) < 0)
  903.                             if (note(2,BREAK)==1)
  904.                                 break;
  905.                         if (!do_find(TEMP_LINK))
  906.                             raus = TRUE;
  907.                         clear_text(t_ptr);
  908.                     }
  909.                     else
  910.                     {
  911.                         if (!do_find(t_icon))
  912.                             raus = TRUE;
  913.                     }
  914.                 }
  915.                 else
  916.                     add_to_projekt(icon, pfad, TRUE);
  917.             }
  918.             fehler = get_direntry(dh, suchPfad, &entry, &attr);
  919.             if (abbruch() && note(2, BREAK) == 1)
  920.                 raus = TRUE;
  921.         } /* while */
  922.         if (fehler != -33 && fehler != -49)
  923.             raus = TRUE;
  924.         Dclosedir(dh);
  925.         if (s_str[0] != EOS)
  926.             destruct_text(t_ptr);
  927.         return raus;
  928.     }
  929.     else        /* es gibt kein Dopendir! */
  930.     {
  931.         DTA    dta,*olddta;
  932.         WORD    fehler;
  933.  
  934.         str_upper(df_muster);                     /* Maske nach Gro₧buchstaben! */
  935.         olddta = Fgetdta ();
  936.         Fsetdta(&dta);
  937.         strcpy(ptr,"*.*");
  938.         raus = FALSE;
  939.         fehler = Fsfirst(pfad,0x0);        /* Dateien */
  940.         do_find_icon = icon;
  941.         while (fehler==0 && !raus)
  942.         {
  943.             if (!(dta.d_attrib&0x1E) && filematch(dta.d_fname, df_muster))
  944.             {
  945.                 strcpy(ptr,dta.d_fname);
  946.                 if (s_str[0]!=EOS)    /* Datei nach String absuchen */
  947.                 {
  948.                     if ((t_icon=still_loaded(pfad))<0)
  949.                     {
  950.                         set_text_name(t_ptr, pfad, FALSE);
  951.                         if (load(t_ptr,FALSE)<0)
  952.                             if (note(2,BREAK)==1)
  953.                                 break;
  954.                         if (!do_find(TEMP_LINK))
  955.                             raus = TRUE;
  956.                         clear_text(t_ptr);
  957.                     }
  958.                     else
  959.                     {
  960.                         if (!do_find(t_icon))
  961.                             raus = TRUE;
  962.                     }
  963.                 }
  964.                 else
  965.                     add_to_projekt(icon,pfad,TRUE);
  966.             }
  967.             fehler = Fsnext();
  968.             if (abbruch() && note(2,BREAK)==1)
  969.                 raus = TRUE;
  970.         }
  971.         if (fehler!=-33 && fehler!=-49)
  972.             raus = TRUE;
  973.         Fsetdta(olddta);
  974.         if (s_str[0]!=EOS)
  975.             destruct_text(t_ptr);
  976.         return raus;
  977.     }
  978. }
  979.  
  980. LOCAL BOOLEAN dfind_rek(UBYTE *pfad, UBYTE *df_muster,WORD icon)
  981. /* Sammelt alle Dateien in einem Pfad REKURSIV auf */
  982. {
  983.     UBYTE     *ptr;
  984.     BOOLEAN    raus;
  985.     PATH        suchPfad;
  986.     LONG        dh;
  987.  
  988.     ptr = pfad + strlen(pfad);
  989.     strcpy(suchPfad, pfad);
  990.     dh = Dopendir(pfad, 0);
  991.     if (dh != -32)
  992.     {
  993.         DIRENTRY entry;
  994.         XATTR     attr;
  995.         LONG        fehler;
  996.  
  997.         if (dh < 0)
  998.             return FALSE;
  999.         fehler = get_direntry(dh, suchPfad, &entry, &attr);
  1000.         raus = FALSE;
  1001.         while (fehler == 0 && !raus)
  1002.         {
  1003.             if ((attr.attr == 16) && strcmp(entry.name, ".") && strcmp(entry.name, ".."))
  1004.             {
  1005.                 strcpy(ptr, entry.name);
  1006.                 strcat(ptr, "\\");
  1007.                 raus = dfind_rek(pfad, df_muster, icon);
  1008.             }
  1009.             fehler = get_direntry(dh, suchPfad, &entry, &attr);
  1010.             if (abbruch() && note(2, BREAK) == 1)
  1011.                 raus = TRUE;
  1012.         } /* while */
  1013.         Dclosedir(dh);
  1014.         ptr[0] = EOS;
  1015.         if (fehler != -33 && fehler != -49)
  1016.             raus = TRUE;
  1017.         if (!raus)
  1018.             raus = dfind(pfad, df_muster, icon);
  1019.         return raus;
  1020.     }
  1021.     else
  1022.     {
  1023.         DTA    dta,*olddta;
  1024.         WORD    fehler;
  1025.  
  1026.         olddta = Fgetdta ();
  1027.         Fsetdta(&dta);
  1028.         strcat(pfad,"*.*");
  1029.         fehler = Fsfirst(pfad,0x10);                    /* Directory-Einräge */
  1030.         raus = FALSE;
  1031.         while (fehler==0 && !raus)
  1032.         {
  1033.             if (dta.d_attrib==0x10 && strcmp(dta.d_fname,".") && strcmp(dta.d_fname,".."))
  1034.             {
  1035.                 strcpy(ptr,dta.d_fname);
  1036.                 strcat(ptr,"\\");
  1037.                 raus = dfind_rek(pfad,df_muster,icon);
  1038.             }
  1039.             fehler = Fsnext();
  1040.             if (abbruch() && note(2,BREAK)==1)
  1041.                 raus = TRUE;
  1042.         }
  1043.         ptr[0] = EOS;
  1044.         if (fehler!=-33 && fehler!=-49)
  1045.             raus = TRUE;
  1046.         if (!raus)
  1047.             raus = dfind(pfad, df_muster,icon);
  1048.         Fsetdta(olddta);
  1049.         return raus;
  1050.     }
  1051. }
  1052.  
  1053. /***************************************************************************/
  1054.  
  1055. LOCAL VOID get_prj_line(WORD link, WORD line, UBYTE *str)
  1056. {
  1057.     TEXTP t_ptr = get_text(link);
  1058.     LINEP lauf;
  1059.  
  1060.     lauf = get_line(&t_ptr->text,line);
  1061.     if (lauf!=NULL)
  1062.     {
  1063.         strcpy(str,TEXT(lauf));
  1064.     }
  1065.     else
  1066.         str[0] = EOS;
  1067. }
  1068.  
  1069. /***************************************************************************/
  1070.  
  1071. LOCAL VOID get_prj_line_file(WORD link, WORD line, UBYTE *str)
  1072. {
  1073.     UBYTE s[256], *ptr;
  1074.  
  1075.     get_prj_line(link,line,s);
  1076.     ptr = s;
  1077.     while (*ptr!=' ' && *ptr!=EOS) ptr++;
  1078.     *ptr = EOS;
  1079.     strcpy(str,s);
  1080. }
  1081.  
  1082. /***************************************************************************/
  1083.  
  1084. LOCAL WORD del_from_projekt (WORD link, WORD line)
  1085. {
  1086.     TEXTP t_ptr = get_text(link);
  1087.     LINEP lauf;
  1088.  
  1089.     lauf = get_line(&t_ptr->text,line);
  1090.     if (lauf!=NULL)
  1091.     {
  1092.         WINDP window = get_window(link);
  1093.  
  1094.         unclick_window();
  1095.         if (t_ptr->text.lines>1)
  1096.         {
  1097.             col_delete(lauf);
  1098.             t_ptr->text.lines--;
  1099.             window->doc.h--;
  1100.             set_sliders(window, VERTICAL, SLPOS+SLSIZE);
  1101.             redraw_window(window,&window->work);
  1102.         }
  1103.         else
  1104.         {
  1105.             REALLOC(&lauf,0,-lauf->len);
  1106.             redraw_window(window,&window->work);
  1107.         }
  1108.         t_ptr->moved++;
  1109.         change_window(window, TRUE);    /* '*' in den Titel */
  1110.     }
  1111.     return 1;
  1112. }
  1113.  
  1114. BOOLEAN add_to_projekt (WORD link, UBYTE *name, BOOLEAN draw)
  1115. {
  1116.     WORD    erg, i;
  1117.     TEXTP t_ptr = get_text(link);
  1118.     PATH    file;
  1119.  
  1120.  
  1121.     if (!caseSens(name, NULL))
  1122.         str_upper(name);
  1123.  
  1124.     strcpy(file,name);
  1125.     if (!make_normalpath(file,TRUE)) return FALSE;
  1126.     erg = 1; i = 0;
  1127.     get_prj_line_file(link,i,file);
  1128.     while (file[0] != EOS && (erg = strcmp(file, name)) < 0)
  1129.     {
  1130.         i++;
  1131.         get_prj_line_file(link,i,file);
  1132.     }
  1133.     if (erg)             /* noch nicht vorhanden */
  1134.     {
  1135.         WINDP window = get_window(link);
  1136.  
  1137.         if (ist_leer(&t_ptr->text))
  1138.             INSERT(&FIRST(&t_ptr->text),0,(short)strlen(name),name);
  1139.         else
  1140.         {
  1141.             LINEP new, lauf;
  1142.  
  1143.             if (i==0)
  1144.                 lauf = &t_ptr->text.head;
  1145.             else
  1146.                 lauf= get_line(&t_ptr->text,i-1);
  1147.             new = new_col_b(name,(short)strlen(name));
  1148.             col_insert(lauf,new);
  1149.             t_ptr->text.lines++;
  1150.             window->doc.h++;
  1151.             if (draw)
  1152.                 set_sliders(window, VERTICAL, SLPOS+SLSIZE);
  1153.         }
  1154.         if (draw)
  1155.             redraw_window(window,&window->work);
  1156.         t_ptr->moved++;
  1157.         change_window(window, TRUE);    /* '*' in den Titel */
  1158.         return TRUE;
  1159.     }
  1160.     return FALSE;
  1161. }
  1162.  
  1163. LOCAL VOID clear_loaded(TEXTP t_ptr)
  1164. {
  1165.     LINEP lauf;
  1166.     UBYTE name[256], param[256];
  1167.     UBYTE *str;
  1168.  
  1169.     lauf = FIRST(&t_ptr->text);
  1170.     while (!IS_TAIL(lauf))
  1171.     {
  1172.         str = TEXT(lauf);
  1173.         while (*str==' ' || *str=='\t') str++;
  1174.         strcpy(name,str);
  1175.         str = name;
  1176.         while (*str!=' ' && *str!='\t' && *str!=EOS) str++;
  1177.         while (*str==' ' || *str=='\t') str++;
  1178.         strcpy(param,str);
  1179.         if (make_normalpath(name,TRUE))
  1180.         {
  1181.             WORD    l;
  1182.  
  1183.             l = (short)strlen(name);
  1184.             str = REALLOC(&lauf, 0, l + 1 + (short)strlen(param) - lauf->len);
  1185.             str = COPYB(str,name,l);
  1186.             *str++ = ' ';
  1187.             strcpy(str,param);
  1188.             NEXT(lauf);
  1189.         }
  1190.         else
  1191.         {
  1192.             if (t_ptr->text.lines>1)
  1193.             {
  1194.                 LINEP help;
  1195.  
  1196.                 help = lauf->nachf;
  1197.                 col_delete(lauf);
  1198.                 t_ptr->text.lines--;
  1199.                 lauf = help;
  1200.             }
  1201.             else
  1202.             {
  1203.                 REALLOC(&lauf,0,-lauf->len);
  1204.                 NEXT(lauf);
  1205.             }
  1206.         }
  1207.     }
  1208. }
  1209.  
  1210. WORD load_projekt(CONST UBYTE *name, BOOLEAN open, WORD icon_x, WORD icon_y, RECT *win)
  1211. /* return: <=0 wurde nicht geladen */
  1212. /*           0    weitere Texte versuchen sinnvoll */
  1213. /*           <0    weiter Texte versuchen nicht sinnvoll */
  1214. {
  1215.     WORD    err, icon;
  1216.     WINDP window;
  1217.     FILENAME datei;
  1218.     PATH    path;
  1219.     TEXTP t_ptr;
  1220.  
  1221.     set_fsel_path(name);
  1222.     file_splitt(name, path, datei);
  1223.     if ((icon=prj_still_loaded(name))>=0)        /* schon geladen */
  1224.     {
  1225.         if (do_icon(icon,DO_OPEN) < 0)            /* nur Fenster auf */
  1226.             note(1, NOWINDOW);
  1227.         if (filematch(name, def_prj_path))        /* Default-Prj wurde geöffnet */
  1228.         {
  1229.             def_icon = icon;
  1230.             set_def_prj();
  1231.         }
  1232.         return icon;
  1233.     }
  1234.     icon = crt_new_prj(name, icon_x, icon_y, win);
  1235.     if (icon<0)
  1236.     {
  1237.         note(1,NOTEXT);
  1238.         return -1;
  1239.     }
  1240.     t_ptr = get_text(icon);;
  1241.     if ((err=load(t_ptr, TRUE))==-33)            /* File not Found */
  1242.     {
  1243.         if (path_exist(path))
  1244.         {
  1245.             if (snote(1,NEWTEXT,datei)==2)
  1246.             {
  1247.                 Icon_edit(icon,DO_DESTRUCT);
  1248.                 return 0;
  1249.             }
  1250.         }
  1251.         else
  1252.         {
  1253.             snote(1, READERR, datei);
  1254.             Icon_edit(icon,DO_DESTRUCT);
  1255.             return 0;
  1256.         }
  1257.     }
  1258.     else if (err)                                        /* anderer Fehler */
  1259.     {
  1260.         snote(1, READERR, datei);
  1261.         Icon_edit(icon,DO_DESTRUCT);
  1262.         return 0;
  1263.     }
  1264.     clear_loaded(t_ptr);
  1265.  
  1266.     window = get_window(icon);
  1267.     window->doc.y = 0;
  1268.     window->doc.h = t_ptr->text.lines;
  1269.     if ((open && !(nkc_kstate() & 3L)) || no_desktop)
  1270.     {
  1271.         if (do_icon(icon,DO_OPEN)<0 && no_desktop)
  1272.         {
  1273.             note(1, NOWINDOW);
  1274.             Icon_edit(icon,DO_DESTRUCT);
  1275.             icon = -2;
  1276.         }
  1277.     }
  1278.  
  1279.     if (filematch(name, def_prj_path))            /* Default-Prj wurde geladen */
  1280.     {
  1281.         def_icon = icon;
  1282.         set_def_prj();
  1283.     }
  1284.     return icon;
  1285. }
  1286.  
  1287. LOCAL VOID destruct(WORD icon)
  1288. {
  1289.     TEXTP t_ptr = get_text(icon);
  1290.     WINDP window = get_window(icon);
  1291.  
  1292.     destruct_window(window);
  1293.     del_icon_from_desk(icon);
  1294.     destruct_text(t_ptr);
  1295.     del_icon(icon);
  1296.     setexcl(used_info,icon);
  1297.     do_all_icon(prj_type,DO_UPDATE);     /* Projekte updaten */
  1298. }
  1299.  
  1300. /***************************************************************************/
  1301. /* Anlegen eines neuen Projekts                                                            */
  1302. /***************************************************************************/
  1303.  
  1304. WORD new_prj(VOID)
  1305. {
  1306.     WORD        icon;
  1307.  
  1308.     icon = crt_new_prj("",-1,-1,NULL);
  1309.     if (icon<0)
  1310.     {
  1311.         note(1,NOTEXT);
  1312.         return -1;
  1313.     }
  1314.     if (!(nkc_kstate() & 3) || no_desktop)
  1315.     {
  1316.         if (do_icon(icon,DO_OPEN)<0)
  1317.         {
  1318.             note(1, NOWINDOW);
  1319.             if (no_desktop)
  1320.             {
  1321.                 Icon_edit(icon, DO_DESTRUCT);
  1322.                 icon = -3;
  1323.             }
  1324.         }
  1325.     }
  1326.     return icon;
  1327. }
  1328. /* new_prj */
  1329.  
  1330. WORD crt_new_prj (CONST UBYTE *filename, WORD icon_x, WORD icon_y, RECT *win)
  1331. {
  1332.     WORD    icon;
  1333.     BOOLEAN    namenlos;
  1334.     TEXTP t_ptr;
  1335.     WINDP window;
  1336.     FILENAME datei;
  1337.     PATH    name;
  1338.  
  1339.     strcpy(name,filename);
  1340.     if (name[0]==EOS)
  1341.     {
  1342.         UBYTE str[20], *ptr;
  1343.         WORD    len;
  1344.  
  1345.         strcpy(name, STRING(NAMENLOS));
  1346.         itoa(++namenlos_anz,str,10);
  1347.         len = (short)strlen(str);
  1348.         ptr = strchr(name,'$');
  1349.         if (ptr!=NULL)
  1350.         {
  1351.             MOVE(ptr+len,ptr+1,(short)strlen(ptr));
  1352.             COPYB(ptr,str,len);
  1353.         }
  1354.         strcpy(datei, name);
  1355.         namenlos = TRUE;
  1356.     }
  1357.     else
  1358.     {
  1359.         file_name(name,datei, FALSE);
  1360.         namenlos = FALSE;
  1361.     }
  1362.     icon = add_icon_to_desk(IPROJEKT, datei, icon_x, icon_y);/* Neues Icon instalieren */
  1363.     if (icon < 0)
  1364.         return -1;
  1365.     if (!add_icon(prj_type,icon))
  1366.     {
  1367.         del_icon_from_desk(icon);
  1368.         return -1;
  1369.     }
  1370.     t_ptr = new_text(icon);                 /* Neuen Text anlegen        */
  1371.     if (t_ptr==NULL)
  1372.     {
  1373.         del_icon(icon);
  1374.         del_icon_from_desk(icon);
  1375.         return -1;
  1376.     }
  1377.     set_text_name(t_ptr, name, namenlos);
  1378.     setincl(used_info,icon);
  1379.     if ((window=create_window(KIND, CLASS_PROJEKT, icon, crt_prj))==NULL)
  1380.     {
  1381.         setexcl(used_info,icon);
  1382.         destruct_text(t_ptr);
  1383.         del_icon(icon);
  1384.         del_icon_from_desk(icon);
  1385.         return -1;
  1386.     }
  1387.     if (win!=NULL && win->w>0)
  1388.     {
  1389.         size_window(window,win,FALSE);
  1390.     }
  1391.     if (!namenlos)
  1392.     {
  1393.         do_all_icon(prj_type,DO_UPDATE);     /* Projekte updaten */
  1394.     }
  1395.     t_ptr->count = local_time->tm_min;
  1396.     return(icon);
  1397. }
  1398.  
  1399. /***************************************************************************/
  1400.  
  1401. LOCAL VOID draw_line (WINDP window, WORD line)
  1402. {
  1403.     TEXTP t_ptr;
  1404.     RECT    r;
  1405.  
  1406.     t_ptr = get_text(window->link);
  1407.     if (line>=t_ptr->text.lines) return;
  1408.     line -= (short)window->doc.y;
  1409.     if (line<0) return;
  1410.     if (line>=window->w_hight) return;
  1411.     r.x = window->work.x;
  1412.     r.y = window->work.y+line*gl_hchar;
  1413.     r.w = window->work.w;
  1414.     r.h = gl_hchar;
  1415.     redraw_window(window,&r);
  1416. }
  1417.  
  1418. LOCAL VOID wi_draw (WINDP window, CONST RECT *d)
  1419. {
  1420.     LINEP lauf;
  1421.     TEXTP t_ptr;
  1422.     WORD    line, y, x, i, link;
  1423.     PATH    name, str;
  1424.  
  1425.     set_clip(TRUE,d);
  1426.     line = (short)window->doc.y;
  1427.     y = window->work.y;
  1428.     x = window->work.x;
  1429.     i = window->w_hight;
  1430.     if (d->y > y)
  1431.     {
  1432.         WORD anz;
  1433.  
  1434.  
  1435.  
  1436.         anz = (d->y-y)/gl_hchar;
  1437.         line += anz;
  1438.         y += anz*gl_hchar;
  1439.         i -= anz;
  1440.     }
  1441.     if (d->y+d->h < window->work.y+window->work.h)
  1442.     {
  1443.         WORD anz;
  1444.  
  1445.         anz = ((window->work.y+window->work.h)-(d->y+d->h))/gl_hchar;
  1446.         i -= anz;
  1447.     }
  1448.     link = window->link;
  1449.     t_ptr = get_text(link);
  1450.     lauf = get_line(&t_ptr->text,line);
  1451.     if (lauf!=NULL)
  1452.     {
  1453.         while ((--i)>=0)
  1454.         {
  1455.             get_prj_line_file(link,line,str);
  1456.             if (str[0]==EOS)
  1457.             {
  1458.                 i++;
  1459.                 break;
  1460.             }
  1461.  
  1462.             if ((still_loaded(str) >= 0) || (prj_still_loaded(str) >= 0)) 
  1463.                 name[0] = '*';
  1464.             else 
  1465.                 name[0] = ' ';
  1466.             make_shortpath(str,name+1,window->w_width-1);
  1467.             if (window==sel_window && setin(sel_objs,line))
  1468.                 outsB(x,y,window->work.w,name);
  1469.             else
  1470.                 outs(x,y,window->work.w,name);
  1471.             line++;
  1472.             y += gl_hchar;
  1473.         }
  1474.     }
  1475.     for (; (--i)>=0; y+=gl_hchar)
  1476.         outc(x,y,window->work.w);
  1477. }
  1478.  
  1479. /***************************************************************************/
  1480.  
  1481. /*
  1482.  * Neue Drag-Funktion!!
  1483.  * Funkt bisher nur für Projekte, aber dafür auch unter N.AES.
  1484.  * Projekt-Elemente können keine qed-Desktop-Funktionen mehr auslösen,
  1485.  * da der beim nächsten Version sowieso 'rausfliegt!!
  1486.  *
  1487.  * Return: Fenster-ID 
  1488. */
  1489. LOCAL WORD drag_objs(WORD w, WORD h, WORD x, WORD y, MKINFO *mk)
  1490. {
  1491.     WORD wh, d;
  1492.  
  1493.     Set_mouse (FLAT_HAND);
  1494.     graf_dragbox(w, h, x, y, desk.x, desk.y, desk.w, desk.h, &d, &d);
  1495.     Last_mouse ();
  1496.     graf_mkstate(&mk->mox, &mk->moy, &d, &mk->kstate);
  1497.     wh = wind_find(mk->mox, mk->moy);
  1498.     return wh;
  1499. }
  1500.  
  1501. LOCAL VOID wi_click (WINDP window, MKINFO *mk)
  1502. {
  1503.     WORD    y, result, mobutton;
  1504.     RECT    *s = &window->work;
  1505.     PATH    str;
  1506.     SET    new_obj;
  1507.  
  1508.     if (mk->mobutton & 2)                            /* Rechtsklick */
  1509.         return;
  1510.  
  1511.     if (!inside(mk->mox,mk->moy,s))
  1512.         return;
  1513.     if (sel_window!=window)
  1514.         unclick_window();
  1515.     set_winfo(window,"");
  1516.     y = (short)(window->doc.y) + (mk->moy - s->y) / gl_hchar;
  1517.     get_prj_line_file(window->link, y, str);
  1518.     if (str[0] == EOS)
  1519.         return;
  1520.  
  1521.     setclr (new_obj);
  1522.     setincl (new_obj, y);                                /* Aktuelles Objekt */
  1523.  
  1524.     if (mk->kstate & (K_RSHIFT|K_LSHIFT))
  1525.     {
  1526.         setxor (sel_objs, new_obj);
  1527.         if (setcmp(sel_objs, NULL))
  1528.             sel_window = NULL;
  1529.         else
  1530.             sel_window = window;
  1531.         draw_line (window, y);
  1532.         if (!setin (sel_objs, y))
  1533.         {
  1534.             graf_mkstate (&result, &result, &mobutton, &result);
  1535.             if (mobutton&1)                                /* Immernoch gedrückt ? */
  1536.                 evnt_button(1, 1, 0, &result, &result, &result, &result);
  1537.             return;
  1538.         }
  1539.     }
  1540.     else                                                         /* noch nicht angeklickt */
  1541.     {
  1542.         graf_mkstate (&result, &result, &mobutton, &result);
  1543.         if (!(mobutton & 1))                             /* Immernoch gedrückt -> nichts tun */
  1544.         {
  1545.             BOOLEAN    re_sel;
  1546.  
  1547.             re_sel = setcmp(new_obj, sel_objs);
  1548.             unclick_window ();                                /* Alle Objekte löschen */
  1549.  
  1550.             /* re_sel ist TRUE, wenn ein Eintrag zum zweiten Mal selektiert wurde
  1551.              * -> wieder deselektieren.
  1552.             */
  1553.             if (!re_sel)
  1554.             {
  1555.                 setincl(sel_objs, y);
  1556.                 sel_window = window;
  1557.             }
  1558.             draw_line(window, y);
  1559.         }
  1560.     }
  1561.  
  1562.     if (mk->breturn == 1 && mk->mobutton & 1)            /* Zieh-Operation */
  1563.     {
  1564.         RECT    first;
  1565.         WORD    num_objs, i, obj;
  1566.         WINDP    qed_win;
  1567.  
  1568.         graf_mkstate (&result, &result, &mobutton, &result);
  1569.         if (!(mobutton&1))
  1570.             return;                     /* Immernoch gedrückt ? */
  1571.  
  1572.         if (window==sel_window)
  1573.             setcpy(new_obj,sel_objs);
  1574.         num_objs = 0;
  1575.         for (i = 0; i < window->w_hight; i++)
  1576.         {
  1577.             if (setin(new_obj, i + (short)window->doc.y))
  1578.             {
  1579.                 if (num_objs == 0)        /* Abmessungen des ersten merken */
  1580.                 {
  1581.                     first.x = s->x;
  1582.                     first.y = s->y + (i * gl_hchar);
  1583.                     first.w = s->w;
  1584.                 }
  1585.                 num_objs++;
  1586.             }
  1587.         }
  1588.         obj = drag_objs(first.w, gl_hchar * num_objs, first.x, first.y, mk);
  1589.         qed_win = find_window(obj);
  1590.         if (qed_win)                                                /* eigenes Fenster */
  1591.         {
  1592.             if (qed_win != window && (qed_win->class == CLASS_PROJEKT ||
  1593.                                               qed_win->class == CLASS_EDIT))
  1594.             {
  1595.                 drag_data_size = num_objs;
  1596.                 for (i = 0; i < window->w_hight; i++)
  1597.                     if (setin(new_obj, i + (short)window->doc.y))
  1598.                     {
  1599.                         get_prj_line_file(window->link, i + (short)window->doc.y, drag_filename);
  1600.                         if (drag_filename[0] == EOS)
  1601.                             break;
  1602.                         if ((mk->kstate & K_ALT) || (qed_win->class == CLASS_PROJEKT))
  1603.                             Icon_drag(qed_win->link, DRAGDROP_FILE);
  1604.                         if (mk->kstate & (K_LSHIFT|K_RSHIFT))
  1605.                             Icon_drag(qed_win->link, DRAGDROP_PATH);
  1606.                     }
  1607.                 drag_data_size = 0;
  1608.             }
  1609.         }
  1610.         else                                            /* fremdes Fenster */
  1611.         {
  1612.             /* 
  1613.              * Bisher wird immer an den Desktop geschickt,
  1614.              * aber nur, wenn dieser AV_DRAG_ON_WINDOW kann.
  1615.             */
  1616.             if ((av_shell_id >= 0) && (av_shell_status & 512))
  1617.             {        
  1618.                 if (num_objs > 1)
  1619.                 {
  1620.                     drag_data_size = (LONG)num_objs * sizeof(PATH);
  1621.                     drag_data = (UBYTE *)Malloc(drag_data_size);
  1622.                     strcpy(drag_data, "");
  1623.                 }
  1624.                 else
  1625.                 {
  1626.                     drag_data_size = 0L;
  1627.                     drag_data = NULL;
  1628.                 }
  1629.                     
  1630.                 for (i=0; i<window->w_hight; i++)
  1631.                 {
  1632.                     if (setin(new_obj, i + (short)window->doc.y))
  1633.                     {
  1634.                         get_prj_line_file(window->link, i + (short)window->doc.y, drag_filename);
  1635.                         if (drag_filename[0] != EOS)
  1636.                         {
  1637.                             if (num_objs > 1)
  1638.                             {
  1639.                                 if (drag_data[0] != EOS)
  1640.                                     strcat(drag_data, " ");
  1641.                                 strcat(drag_data, drag_filename);
  1642.                             }
  1643.                         /*    else steht das Arg in drag_filename */
  1644.                         }
  1645.                     }
  1646.                 } /* for */
  1647.  
  1648.                 if (num_objs > 1)
  1649.                     send_avdrag(obj, mk, DRAGDROP_DATA);
  1650.                 else
  1651.                     send_avdrag(obj, mk, DRAGDROP_PATH);
  1652.  
  1653.                 if (drag_data_size > 0)
  1654.                 {
  1655.                     Mfree(drag_data);
  1656.                     drag_data_size = 0;
  1657.                 }
  1658.             } /* if av_ */
  1659.         } /* if !my_window */
  1660.     }
  1661.     if (mk->breturn==2)                                /* Doppelklick */
  1662.     {
  1663.         unclick_window();
  1664.         sel_window = window;
  1665.         setincl(sel_objs,y);
  1666.         draw_line(window,y);
  1667.         graf_mkstate (&result, &result, &mobutton, &result);
  1668.         if (mobutton&1)                                /* Immernoch gedrückt ? */
  1669.             evnt_button(1, 1, 0, &result, &result, &result, &result);
  1670.         do_icon(window->link+SUB_ICON,DO_OPEN);
  1671.     }
  1672. }
  1673.  
  1674. /***************************************************************************/
  1675.  
  1676. LOCAL VOID wi_unclick (WINDP window)
  1677. {
  1678.     SET    help;
  1679.     WORD    i, max;
  1680.  
  1681.     setcpy(help,sel_objs);
  1682.     setclr(sel_objs);
  1683.     max = setmax(help);
  1684.     for (i=setmin(help); i<=max; i++)
  1685.         if (setin(help,i))
  1686.             draw_line(window,i);
  1687.     set_winfo(window,"");
  1688. }
  1689.  
  1690. /***************************************************************************/
  1691.  
  1692. LOCAL VOID sel_line(WINDP window, WORD line)
  1693. {
  1694.     if (sel_window!=NULL)
  1695.         unclick_window();
  1696.     sel_window = window;
  1697.     setincl(sel_objs,line);
  1698.     draw_line(window,line);
  1699.     line -= (short) window->doc.y;
  1700.     if (line<0)
  1701.         arrow_window(window,WA_UPLINE,-line);
  1702.     else
  1703.     {
  1704.         line -= (window->w_hight-1);
  1705.         if (line>0)
  1706.             arrow_window(window,WA_DNLINE,line);
  1707.     }
  1708. }
  1709.  
  1710.  
  1711. LOCAL VOID shift_up(WINDP window)
  1712. {
  1713.     WORD    i;
  1714.  
  1715.     if (window->doc.h == 0)
  1716.         return;
  1717.     if (sel_window == window)
  1718.     {
  1719.         i = setmin(sel_objs);
  1720.         if (i == 0)
  1721.             return ;
  1722.         i -= window->w_hight;
  1723.         if (i < 0)
  1724.             i = 0;
  1725.         sel_line(window,i);
  1726.     }
  1727.     else
  1728.         sel_line(window, (short)window->doc.h-1);
  1729. }
  1730.  
  1731. LOCAL VOID shift_down(WINDP window)
  1732. {
  1733.     WORD    i;
  1734.  
  1735.     if (window->doc.h == 0)
  1736.         return ;
  1737.     if (sel_window == window)
  1738.     {
  1739.         i = setmin(sel_objs);
  1740.         if (i == window->doc.h - 1)
  1741.             return ;
  1742.         i += window->w_hight;
  1743.         if (i >= window->doc.h)
  1744.             i = (short) window->doc.h - 1;
  1745.         sel_line(window,i);
  1746.     }
  1747.     else
  1748.         sel_line(window,0);
  1749. }
  1750.  
  1751. LOCAL BOOLEAN wi_key (WINDP window, MKINFO *mk)
  1752. {
  1753.     UBYTE     asc;
  1754.     WORD        i, key;
  1755.     BOOLEAN    erg;
  1756.  
  1757.     /* Damit F-Tasten zum System-Desktop kommen! */
  1758.     if ((mk->scan_code >= 0x3B00 && mk->scan_code <= 0x4400) ||
  1759.          (mk->scan_code >= 0x5400 && mk->scan_code <= 0x5D00))
  1760.         return FALSE;
  1761.  
  1762.     erg = FALSE;
  1763.     if ((mk->kreturn & NKF_FUNC) && (mk->kreturn & NKF_SHIFT))
  1764.     {
  1765.         key = mk->kreturn & ~(NKF_FUNC|NKF_SHIFT);
  1766.         switch (key)
  1767.         {
  1768.             case NK_CLRHOME :
  1769.                 v_slider(window, 1000);
  1770.                 sel_line(window, (short)window->doc.h - 1);
  1771.                 erg = TRUE;
  1772.                 break;
  1773.             case NK_UP    :
  1774.                 shift_up(window);
  1775.                 erg = TRUE;
  1776.                 break;
  1777.             case NK_DOWN:
  1778.                 shift_down(window);
  1779.                 erg = TRUE;
  1780.                 break;
  1781.             default:
  1782.                 erg = FALSE;
  1783.                 break;
  1784.         }
  1785.     }
  1786.     else if (mk->kreturn & NKF_FUNC)
  1787.     {
  1788.         key = mk->kreturn & ~(NKF_FUNC);
  1789.         switch (key)
  1790.         {
  1791.             case NK_RET :
  1792.                 do_icon(window->link+SUB_ICON, DO_OPEN);
  1793.                 erg = TRUE;
  1794.                 break;
  1795.             case NK_CLRHOME :
  1796.                 v_slider(window, 0);
  1797.                 sel_line(window,0);
  1798.                 erg = TRUE;
  1799.                 break;
  1800.             case NK_UP :
  1801.                 if (window->doc.h == 0)
  1802.                     break;
  1803.                 if (sel_window == window)
  1804.                 {
  1805.                     i = setmin(sel_objs);
  1806.                     if (i == 0)
  1807.                         break;
  1808.                     i--;
  1809.                     if (i < 0)
  1810.                         i = 0;
  1811.                     sel_line(window,i);
  1812.                 }
  1813.                 else
  1814.                     sel_line(window, (short)window->doc.h - 1);
  1815.                 erg = TRUE;
  1816.                 break;
  1817.             case NK_DOWN:
  1818.                 if (window->doc.h == 0)
  1819.                     break;
  1820.                 if (sel_window == window)
  1821.                 {
  1822.                     i = setmin(sel_objs);
  1823.                     if (i==window->doc.h-1)
  1824.                         break;
  1825.                     i++;
  1826.                     if (i >= window->doc.h)
  1827.                         i = (short) window->doc.h-1;
  1828.                     sel_line(window,i);
  1829.                 }
  1830.                 else
  1831.                     sel_line(window,0);
  1832.                 erg = TRUE;
  1833.                 break;
  1834.             case NK_HELP :            /* damit das bei desktop noch ankommt! */
  1835.                 erg = FALSE;
  1836.                 break;
  1837.             case NK_M_PGUP:                /* Mac: page up -> shift-up */
  1838.                 shift_up(window);
  1839.                 erg = TRUE;
  1840.                 break;
  1841.             case NK_M_PGDOWN:                /* Mac: page down -> shift-down */
  1842.                 shift_down(window);
  1843.                 erg = TRUE;
  1844.                 break;
  1845.             case NK_M_END:                    /* Mac: end -> shift-home */
  1846.                 v_slider(window, 1000);
  1847.                 sel_line(window, (short)window->doc.h - 1);
  1848.                 erg = TRUE;
  1849.                 break;
  1850.             default:
  1851.                 if (!(mk->ctrl) && !(mk->alt) && (!mk->shift) && mk->ascii_code)
  1852.                 {
  1853.                     if (sel_window == window)
  1854.                         unclick_window();
  1855.                     else
  1856.                         set_winfo(window,"");
  1857.                     erg = TRUE;
  1858.                 }
  1859.                 else
  1860.                     erg = FALSE;
  1861.                 break;
  1862.         }
  1863.     }
  1864.     else
  1865.     {
  1866.         WORD        l;
  1867.         FILENAME name;
  1868.         PATH        str, info;
  1869.  
  1870.         /* Auto-Locator */
  1871.         asc = nkc_toupper(mk->ascii_code);
  1872.         strcpy(info,window->info);
  1873.         l = (short) strlen(info);
  1874.         info[l++] = asc;
  1875.         info[l] = EOS;
  1876.         i = 0;
  1877.         do
  1878.         {
  1879.             get_prj_line_file(window->link,i,str);
  1880.             i++;
  1881.             if (str[0]==EOS)
  1882.                 break;
  1883.             file_name(str,name, FALSE);
  1884.             str_upper(name);
  1885.         }
  1886.         while (strncmp(name, info, l) != 0);
  1887.         if (str[0]!=EOS)
  1888.         {
  1889.             sel_line(window,i-1);
  1890.             set_winfo(window,info);
  1891.         }
  1892.         erg = TRUE;
  1893.     }
  1894.     return erg;
  1895. }
  1896.  
  1897. /***************************************************************************/
  1898.  
  1899. LOCAL VOID    wi_snap (WINDP window, RECT *new, WORD mode)
  1900. {
  1901.     WORD w, ex, pxy[8];
  1902.  
  1903.     /* zunächst Platz für min. 1+Filename+1 im Fenster */
  1904.     vqt_extent(vdi_handle, "x", pxy);
  1905.     ex = pxy[2] - pxy[0];
  1906.     w = new->w;
  1907.     if (w < 14 * ex)
  1908.         w = 14 * ex;
  1909.  
  1910.     /* nun noch Platz für Fenstertitel (1+8+1) */
  1911.     if (w < sys_wchar * 10)
  1912.         w = sys_wchar * 10;
  1913.  
  1914.     new->w = w;
  1915. }
  1916.  
  1917.  
  1918. LOCAL VOID        wi_iconify        (WINDOWP window)
  1919. {
  1920.     TEXTP     t_ptr = get_text(window->link);
  1921.     FILENAME short_name;
  1922.  
  1923.     make_shortpath(t_ptr->filename, short_name, 8);
  1924.     set_wname(window, short_name);
  1925. }
  1926.  
  1927.  
  1928. LOCAL VOID        wi_uniconify    (WINDOWP window)
  1929. {
  1930.     TEXTP     t_ptr = get_text(window->link);
  1931.     FILENAME name;
  1932.  
  1933.     file_name(t_ptr->filename, name, TRUE);
  1934.     set_wname(window, name);
  1935. }
  1936.  
  1937. /***************************************************************************/
  1938. /* Kreieren eines Fensters                                                                 */
  1939. /***************************************************************************/
  1940.  
  1941. LOCAL VOID crt_prj (WORD icon, WINDP window)
  1942. {
  1943.     FILENAME name;
  1944.     WORD        initw, inith;
  1945.     TEXTP     t_ptr;
  1946.  
  1947.     t_ptr  = get_text(icon);
  1948.     initw  = gl_wchar * 13;
  1949.     inith  = (desk.h / gl_hchar) * gl_hchar - 7 * gl_hchar;
  1950.  
  1951.     window->flags        = FLAGS;
  1952.     window->doc.w        = 13;
  1953.     window->doc.h        = t_ptr->text.lines;
  1954.     window->changed    = (t_ptr->moved!=0);
  1955.     window->xfac        = gl_wchar;
  1956.     window->yfac        = gl_hchar;
  1957.     window->w_width    = initw/gl_wchar;
  1958.     window->w_hight    = inith/gl_hchar;
  1959.     window->work.x        = sys_wchar + 2 * 8;
  1960.     window->work.y        = 60;
  1961.     window->work.w        = initw;
  1962.     window->work.h        = inith;
  1963.     window->draw        = wi_draw;
  1964.     window->click        = wi_click;
  1965.     window->unclick    = wi_unclick;
  1966.     window->key         = wi_key;
  1967.     window->snap        = wi_snap;
  1968.     window->icon        = winicon;
  1969.     window->iconify    = wi_iconify;
  1970.     window->uniconify = wi_uniconify;
  1971.  
  1972.     if (t_ptr->namenlos)
  1973.         strcpy(name, t_ptr->filename);
  1974.     else
  1975.         file_name(t_ptr->filename, name, TRUE);
  1976.     set_wname(window, name);
  1977.     set_winfo(window,"");
  1978. } /* crt_edit */
  1979.  
  1980. /***************************************************************************/
  1981. /* Öffnen des Objekts                                                                        */
  1982. /***************************************************************************/
  1983.  
  1984. LOCAL BOOLEAN open_prj (WORD icon)
  1985. {
  1986.     BOOLEAN    ok;
  1987.     WINDP window = get_window(icon);
  1988.  
  1989.     if (window->opened || (window->flags & WI_ICONIFIED))
  1990.     /* Doppelklick auf Icon und Fenster ist schon offen */
  1991.     {
  1992.         top_window (window);
  1993.         ok = TRUE;
  1994.     }
  1995.     else
  1996.     {
  1997.         ok = open_window (window);
  1998.     }
  1999.     return (ok);
  2000. } /* open_prj */
  2001.  
  2002. /***************************************************************************/
  2003. /* Info des Objekts                                                                            */
  2004. /***************************************************************************/
  2005.  
  2006. LOCAL LONG len, bytes;
  2007. LOCAL WORD    anz, i_icon;
  2008.  
  2009. LOCAL WORD count(WORD icon, WORD i)
  2010. {
  2011.     PATH    name;
  2012.  
  2013.     anz++;
  2014.     get_prj_line_file(icon,i,name);
  2015.     if ((icon=still_loaded(name))>=0)
  2016.     {
  2017.         TEXTP t_ptr;
  2018.  
  2019.         t_ptr = get_text(icon);
  2020.         bytes += textring_bytes(&t_ptr->text, t_ptr->ending);
  2021.         len += t_ptr->text.lines;
  2022.         return 1;
  2023.     }
  2024.     else
  2025.     {
  2026.         LONG    b,l;
  2027.         WORD    antw;
  2028.  
  2029.         antw = infoload(name,&b,&l);
  2030.         bytes += b;
  2031.         len += l;
  2032.         return (antw==0)?1:0;
  2033.     }
  2034. }
  2035.  
  2036. LOCAL BOOLEAN info_projekt (WORD icon)
  2037. {
  2038.     UBYTE     str[32], date[11];
  2039.     TEXTP     t_ptr = get_text(icon);
  2040.     WORD        r_anz, i, antw;
  2041.     SET        all;
  2042.     BOOLEAN    quit = FALSE;
  2043.     DIALINFO    dial;
  2044.  
  2045.     disable_objc(prjinfo, IPRJSCAN, FALSE);
  2046.     i_icon = icon;
  2047.     make_shortpath(t_ptr->filename, str, 30);
  2048.     fill_ptext (prjinfo, PRJNAME, str);         /* Name mit Pfad */
  2049.     if (ist_leer(&t_ptr->text))
  2050.         r_anz = 0;
  2051.     else
  2052.         r_anz = (short) t_ptr->text.lines;
  2053.     ltoa(r_anz,str,10);
  2054.     fill_ptext (prjinfo, PRJFILES, str);        /* Dateien-Anzahl */
  2055.     str[0] = EOS;
  2056.     fill_ptext (prjinfo, PRJLEN , str);         /* Länge in Bytes */
  2057.     fill_ptext (prjinfo, PRJZEILE , str);        /* Länge in Zeilen */
  2058.     if (t_ptr->namenlos)
  2059.         str[0] = date[0] = EOS;
  2060.     else
  2061.         file_time (t_ptr->filename, date, str);
  2062.     fill_ptext (prjinfo, PRJDATUM, date);        /* Datum */
  2063.     fill_ptext (prjinfo, PRJZEIT, str);         /* Uhrzeit */
  2064.  
  2065.     Arrow_mouse();
  2066.     open_dial(prjinfo, FALSE, NULL, &dial);
  2067.     dial_draw(&dial);
  2068.     do
  2069.     {
  2070.         antw = dial_do(&dial, NULL) & 0x7FFF;
  2071.         switch (antw)
  2072.         {
  2073.             case IPRJSCAN:
  2074.                 if (ist_leer(&t_ptr->text))
  2075.                     r_anz = 0;
  2076.                 else
  2077.                     r_anz = (short) t_ptr->text.lines;
  2078.                 anz = 0;
  2079.                 bytes = len = 0;
  2080.                 setclr(all);
  2081.                 for (i=r_anz; (--i)>=0; )
  2082.                     setincl(all,i);
  2083.                 do_for_prj(i_icon, all, count, TRUE);
  2084.                 if (r_anz==anz)                                    /* alle durchlaufen */
  2085.                     ltoa(bytes,str,10);
  2086.                 else
  2087.                     str[0] = EOS;
  2088.                 fill_ptext (prjinfo, PRJLEN , str);         /* Länge in Bytes */
  2089.                 draw_Objc(prjinfo, PRJLEN, 1);
  2090.                 if (r_anz==anz)
  2091.                     ltoa(len,str,10);
  2092.                 else
  2093.                     str[0] = EOS;
  2094.                 fill_ptext (prjinfo, PRJZEILE , str);        /* Länge in Zeilen */
  2095.                 draw_Objc(prjinfo, PRJZEILE, 1);
  2096.                 if (r_anz==anz)                                    /* alle durchlaufen */
  2097.                 {
  2098.                     disable_objc(prjinfo, IPRJSCAN, TRUE);
  2099.                     draw_Objc(prjinfo, IPRJSCAN, 1);
  2100.                 }
  2101.                 break;
  2102.             default:
  2103.                 quit = TRUE;
  2104.                 break;
  2105.         }
  2106.         select_objc(prjinfo, antw, FALSE);
  2107.         draw_Objc(prjinfo, antw, 1);
  2108.     }
  2109.     while (!quit);
  2110.     dial_end(&dial);
  2111.     Last_mouse();
  2112.     return TRUE;
  2113. }
  2114.  
  2115. /******************************************************************************/
  2116. /* Default-Projekt                                                                                */
  2117. /******************************************************************************/
  2118.  
  2119. VOID    open_def_prj(VOID)
  2120. {
  2121.     if (def_prj_path[0] != EOS && global_shift)    /* altes abmelden */
  2122.     {
  2123.         def_prj_path[0] = EOS;
  2124.         def_icon = -1;
  2125.     }
  2126.     else if (def_prj_path[0] != EOS)                 /* bekanntes öffnen */
  2127.         load_projekt(def_prj_path, TRUE, -1, -1, NULL);
  2128.     else
  2129.         select_def_prj();                                 /* nix bekannt, also auswählen */
  2130.     set_def_prj();         /* Menü anpassen */
  2131. }
  2132.  
  2133.  
  2134. VOID    add_to_def(VOID)
  2135. {
  2136.     WINDP w;
  2137.  
  2138.     w = real_top();
  2139.     if (w == NULL)
  2140.         return;
  2141.     if (w->link != def_icon)
  2142.     {
  2143.         TEXTP t_ptr = get_text(w->link);
  2144.  
  2145.         if (!t_ptr->namenlos)
  2146.             add_to_projekt(def_icon, t_ptr->filename, TRUE);
  2147.     }
  2148. }
  2149.  
  2150.  
  2151. LOCAL VOID    select_def_prj(VOID)
  2152. {
  2153.     FSEL        fsel = {"", "*.QPJ"};
  2154.     PATH        name = "";
  2155.  
  2156.     if (select_file(&fsel, name, STRING(DEFPRJ2STR)))
  2157.     {
  2158.         strcpy(def_prj_path, name);
  2159.         load_projekt(def_prj_path, TRUE, -1, -1, NULL);
  2160.     }
  2161. }
  2162.  
  2163.  
  2164. VOID    set_def_prj(VOID)
  2165. {
  2166.     FILENAME n = "";
  2167.  
  2168.     if (def_icon == -1 || def_prj_path[0] == EOS)
  2169.     {
  2170.         menu_ienable(menu, MTAKEPRJ, FALSE);
  2171.         menu_icheck(menu, MPROJEKT, FALSE);
  2172.     }
  2173.     else
  2174.     {
  2175.         menu_ienable(menu, MTAKEPRJ, TRUE);
  2176.         menu_icheck(menu, MPROJEKT, TRUE);
  2177.     }
  2178.  
  2179.     /* Name ins Menü eintragen */
  2180.     if (def_prj_path[0] != EOS)
  2181.         file_name(def_prj_path, n, FALSE);
  2182.     else
  2183.         strcpy(n, STRING(DEFPRJSTR));
  2184.     fillup_menu(MPROJEKT, n, 2);
  2185. }
  2186.  
  2187.  
  2188. /******************************************************************************/
  2189. /* Verwaltung der Liste mit der letzten Position                                        */
  2190. /* Die Liste wird nur benutzt, wenn aus einem Projekt eine Datei                    */
  2191. /* geladen wird.                                                                                    */
  2192. /******************************************************************************/
  2193.  
  2194. /* Sucht in der Liste nach einem Eintrag */
  2195. LOCAL BOOLEAN    get_lastPos (CONST UBYTE *filename, WORD *x, LONG *y)
  2196. {
  2197.     LINEP lauf;
  2198.     UBYTE *txt, *p;
  2199.     PATH    name;
  2200.  
  2201.     lauf = FIRST(&lastPos);
  2202.     if (lauf == NULL)
  2203.         return FALSE;
  2204.  
  2205.     while (!IS_LAST(lauf))
  2206.     {
  2207.         txt = TEXT(lauf);
  2208.         strcpy(name, txt);
  2209.         p = strchr(name, ' ');
  2210.         *p = EOS;
  2211.         if (filematch(name, filename))
  2212.         {
  2213.             sscanf(txt, "%s %d %ld", name, x, y);
  2214.             return TRUE;
  2215.         }
  2216.         NEXT(lauf);
  2217.     }
  2218.     return FALSE;
  2219. }
  2220.  
  2221. LOCAL VOID    insert_lastPos(CONST UBYTE *name, WORD x, LONG y)
  2222. {
  2223.     LINEP col;
  2224.     UBYTE str[256];
  2225.  
  2226.     sprintf(str, "%s %d %ld", name, x, y);
  2227.     col = new_col_w(str, (short)strlen(str));
  2228.     col_insert(&(lastPos.head), col);
  2229.     lastPos.lines++;
  2230. }
  2231.  
  2232. VOID update_lastPos(CONST UBYTE *filename, WORD x, LONG y)
  2233. {
  2234.     LINEP lauf;
  2235.     UBYTE *txt, *p;
  2236.     PATH    name;
  2237.     UBYTE str[256];
  2238.  
  2239.     lauf = FIRST(&lastPos);
  2240.     if (lauf == NULL)
  2241.         return ;
  2242.  
  2243.     while (!IS_LAST(lauf))
  2244.     {
  2245.         txt = TEXT(lauf);
  2246.         strcpy(name, txt);
  2247.         p = strchr(name, ' ');
  2248.         *p = EOS;
  2249.         if (filematch(name, filename))
  2250.         {
  2251.             sprintf(str, "%s %d %ld", name, x, y); /* Eintrag aktualisieren */
  2252.             col_delete(lauf);
  2253.             lastPos.lines--;
  2254.             insert_lastPos(filename, x, y);
  2255.             return;
  2256.         }
  2257.         NEXT(lauf);
  2258.     }
  2259. }
  2260.  
  2261. /******************************************************************************/
  2262. /* Initialisierung                                                                                */
  2263. /******************************************************************************/
  2264.  
  2265. VOID    init_projekt(VOID)
  2266. {
  2267.     get_path(df_path, 0);                            /* Aktuellen Pfad holen */
  2268.     namenlos_anz = 0;
  2269.     setclr(used_info);
  2270.     prj_type = decl_icon_type(icon_test,icon_edit,icon_exist,icon_drag);
  2271.     def_prj_path[0] = EOS;
  2272.     def_icon = -1;
  2273.     init_textring(&lastPos);
  2274. }
  2275.  
  2276. VOID    term_project(VOID)
  2277. {
  2278. /* Führt unte MultiTOS zu Speicherverletzung, warum auch immer */
  2279. /*    kill_textring(&lastPos); */
  2280. }
  2281.